/**
 * 离线模式组件
 * 在网络不可用时提供基本功能
 */

const logger = require('../../utils/logger').logger;
const networkManager = require('../../utils/network-manager');
const envDetector = require('../../utils/env-detector');

Component({
  /**
   * 组件的属性列表
   */
  properties: {
    deviceId: {
      type: String,
      value: ''
    },
    deviceType: {
      type: String,
      value: ''
    },
    showHeader: {
      type: Boolean,
      value: true
    }
  },

  /**
   * 组件的初始数据
   */
  data: {
    isOffline: false,
    networkType: 'unknown',
    device: null,
    cachedSettings: null,
    lastSyncTime: null,
    lastSyncTimeFormatted: '',
    showReconnectTips: false,
    reconnecting: false,
    isDevTools: false
  },

  lifetimes: {
    attached() {
      // 检测是否在开发者工具环境
      this.setData({
        isDevTools: envDetector.isDevTools()
      });
      
      // 组件被加载时，检查当前网络状态
      this._checkNetworkStatus();
      
      // 注册网络状态变化回调
      this._registerNetworkCallback();
      
      // 加载设备缓存数据
      this._loadDeviceCachedData();
      
      // 设置时间格式化器
      this._formatSyncTime();
    },
    
    detached() {
      // 组件被移除时，注销网络状态变化回调
      this._unregisterNetworkCallback();
    }
  },

  observers: {
    'lastSyncTime': function(timestamp) {
      if (timestamp) {
        this._formatSyncTime();
      }
    }
  },

  /**
   * 组件的方法列表
   */
  methods: {
    /**
     * 格式化同步时间
     * @private
     */
    _formatSyncTime() {
      const timestamp = this.data.lastSyncTime;
      if (!timestamp) return;
      
      try {
        const date = new Date(timestamp);
        const formattedTime = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}-${String(date.getDate()).padStart(2, '0')} ${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}:${String(date.getSeconds()).padStart(2, '0')}`;
        this.setData({
          lastSyncTimeFormatted: formattedTime
        });
      } catch (e) {
        logger.error('格式化同步时间失败', e);
      }
    },
    
    /**
     * 检查网络状态
     * @private
     */
    _checkNetworkStatus() {
      const networkType = networkManager.getNetworkType();
      const isOffline = networkType === 'none';
      
      this.setData({
        networkType: networkType,
        isOffline: isOffline
      });
      
      // 在开发者工具环境中，对于特定场景模拟离线模式
      if (this.data.isDevTools && Math.random() < 0.3) {
        // 30%概率模拟离线状态，用于测试
        this.setData({
          isOffline: true
        });
        
        logger.info('开发者工具环境: 模拟离线状态');
      }
      
      // 如果离线，尝试连接蓝牙设备
      if (this.data.isOffline && this.data.deviceId) {
        this._tryConnectBluetooth();
      }
    },
    
    /**
     * 注册网络状态变化回调
     * @private
     */
    _registerNetworkCallback() {
      // 创建回调函数
      this.networkCallback = (networkType) => {
        const isOffline = networkType === 'none';
        
        logger.info(`离线模式组件检测到网络变化: ${networkType}, 离线: ${isOffline}`);
        
        this.setData({
          networkType: networkType,
          isOffline: isOffline
        });
        
        // 网络状态发生变化时的处理
        if (isOffline) {
          // 网络断开，进入离线模式，尝试连接蓝牙设备
          this._tryConnectBluetooth();
        } else {
          // 网络恢复，显示重连提示
          if (this.data.device) {
            this.setData({
              showReconnectTips: true
            });
          }
        }
      };
      
      // 注册回调
      networkManager.addCallback(this.networkCallback);
    },
    
    /**
     * 注销网络状态变化回调
     * @private
     */
    _unregisterNetworkCallback() {
      if (this.networkCallback) {
        networkManager.removeCallback(this.networkCallback);
        this.networkCallback = null;
      }
    },
    
    /**
     * 加载设备缓存数据
     * @private
     */
    _loadDeviceCachedData() {
      const deviceId = this.data.deviceId;
      if (!deviceId) return;
      
      try {
        // 尝试从存储中读取设备缓存数据
        const cacheKey = `device_cache_${deviceId}`;
        const cachedData = wx.getStorageSync(cacheKey);
        
        if (cachedData) {
          const device = JSON.parse(cachedData);
          const cachedSettings = wx.getStorageSync(`device_settings_${deviceId}`);
          const lastSyncTime = wx.getStorageSync(`device_sync_time_${deviceId}`);
          
          this.setData({
            device: device,
            cachedSettings: cachedSettings ? JSON.parse(cachedSettings) : null,
            lastSyncTime: lastSyncTime || null
          });
          
          this._formatSyncTime();
          
          logger.info(`已加载设备[${deviceId}]的缓存数据`, device);
          
          // 触发设备缓存加载完成事件
          this.triggerEvent('cacheLoaded', { device: device });
        } else {
          // 开发者工具环境中模拟缓存数据
          if (this.data.isDevTools) {
            logger.info(`开发者工具环境: 模拟设备[${deviceId}]缓存数据`);
            
            const mockDevice = {
              id: deviceId,
              name: '模拟设备',
              type: this.data.deviceType || 'freshwater_lamp',
              firmware: 'v1.0.0',
              hardware: 'v2.0',
              mac: 'AA:BB:CC:DD:EE:FF'
            };
            
            const mockSettings = {
              brightness: 80,
              mode: 'auto',
              schedule: [
                { time: '08:00', value: 100 },
                { time: '20:00', value: 30 }
              ]
            };
            
            this.setData({
              device: mockDevice,
              cachedSettings: mockSettings,
              lastSyncTime: Date.now() - 3600000 // 1小时前
            });
            
            this._formatSyncTime();
            
            // 触发设备缓存加载完成事件
            this.triggerEvent('cacheLoaded', { device: mockDevice });
          } else {
            logger.warn(`未找到设备[${deviceId}]的缓存数据`);
          }
        }
      } catch (e) {
        logger.error(`加载设备[${deviceId}]的缓存数据失败`, e);
      }
    },
    
    /**
     * 尝试通过蓝牙连接设备
     * @private
     */
    _tryConnectBluetooth() {
      const deviceId = this.data.deviceId;
      if (!deviceId) return;
      
      // 获取设备服务
      const app = getApp();
      const deviceService = app.globalData.deviceService;
      
      if (!deviceService) {
        logger.error('设备服务未初始化');
        return;
      }
      
      logger.info(`离线模式下尝试通过蓝牙连接设备[${deviceId}]`);
      
      try {
        // 在开发者工具环境中进行模拟连接
        if (this.data.isDevTools) {
          logger.info(`开发者工具环境: 模拟蓝牙连接设备[${deviceId}]`);
          
          // 延迟模拟连接结果
          setTimeout(() => {
            // 80%概率连接成功
            if (Math.random() < 0.8) {
              logger.info(`开发者工具环境: 模拟蓝牙连接设备[${deviceId}]成功`);
              
              this.triggerEvent('bluetoothConnected', { 
                deviceId: deviceId,
                mode: deviceService.CONNECTION_MODE ? deviceService.CONNECTION_MODE.BLUETOOTH : 1
              });
              
              this._syncLocalSettings();
            } else {
              logger.error(`开发者工具环境: 模拟蓝牙连接设备[${deviceId}]失败`);
              
              this.triggerEvent('bluetoothFailed', { 
                deviceId: deviceId,
                error: { errMsg: '模拟连接失败' }
              });
            }
          }, 1000);
          
          return;
        }
        
        // 真机环境下连接蓝牙设备
        deviceService.connectDevice(deviceId, {
          mode: deviceService.CONNECTION_MODE.BLUETOOTH, // 强制使用蓝牙模式
          onConnected: (info) => {
            logger.info(`离线模式下设备[${deviceId}]蓝牙连接成功`);
            
            this.triggerEvent('bluetoothConnected', { 
              deviceId: deviceId,
              mode: info.mode
            });
            
            this._syncLocalSettings();
          },
          onFailed: (err) => {
            logger.error(`离线模式下设备[${deviceId}]蓝牙连接失败`, err);
            
            this.triggerEvent('bluetoothFailed', { 
              deviceId: deviceId,
              error: err
            });
          }
        });
      } catch (e) {
        logger.error(`尝试连接设备[${deviceId}]失败`, e);
      }
    },
    
    /**
     * 同步本地设置到设备
     * @private
     */
    _syncLocalSettings() {
      const deviceId = this.data.deviceId;
      const cachedSettings = this.data.cachedSettings;
      
      if (!deviceId || !cachedSettings) return;
      
      // 获取设备服务
      const app = getApp();
      const deviceService = app.globalData.deviceService;
      
      if (!deviceService) {
        logger.error('设备服务未初始化');
        return;
      }
      
      logger.info(`离线模式下同步本地设置到设备[${deviceId}]`);
      
      try {
        // 在开发者工具环境中模拟发送命令
        if (this.data.isDevTools) {
          logger.info(`开发者工具环境: 模拟同步设置到设备[${deviceId}]`);
          
          setTimeout(() => {
            if (Math.random() < 0.9) {
              logger.info(`开发者工具环境: 模拟同步设置到设备[${deviceId}]成功`);
              
              this.triggerEvent('syncSuccess', { 
                deviceId: deviceId,
                settings: cachedSettings
              });
            } else {
              logger.error(`开发者工具环境: 模拟同步设置到设备[${deviceId}]失败`);
              
              this.triggerEvent('syncFailed', { 
                deviceId: deviceId,
                error: { errMsg: '模拟同步失败' }
              });
            }
          }, 800);
          
          return;
        }
        
        // 真机环境下发送命令
        deviceService.sendBluetoothCommand(deviceId, cachedSettings, {
          onSuccess: () => {
            logger.info(`离线模式下同步设置到设备[${deviceId}]成功`);
            
            this.triggerEvent('syncSuccess', { 
              deviceId: deviceId,
              settings: cachedSettings
            });
          },
          onFailed: (err) => {
            logger.error(`离线模式下同步设置到设备[${deviceId}]失败`, err);
            
            this.triggerEvent('syncFailed', { 
              deviceId: deviceId,
              error: err
            });
          }
        });
      } catch (e) {
        logger.error(`同步设置到设备[${deviceId}]失败`, e);
      }
    },
    
    /**
     * 尝试重新连接在线模式
     */
    reconnect() {
      this.setData({
        reconnecting: true,
        showReconnectTips: false
      });
      
      // 获取网络管理器
      networkManager.testConnectivity().then(result => {
        if (result.success) {
          logger.info('网络连接测试成功，延迟:', result.latency);
          
          // 触发重连事件
          this.triggerEvent('reconnect', {
            success: true,
            latency: result.latency
          });
          
          try {
            // 切换回WiFi模式
            const app = getApp();
            const deviceService = app.globalData.deviceService;
            
            if (deviceService && this.data.deviceId) {
              if (deviceService.CONNECTION_MODE) {
                deviceService.connectDevice(this.data.deviceId, {
                  mode: deviceService.CONNECTION_MODE.WIFI
                });
              } else {
                logger.warn('设备服务连接模式未定义，无法切换到WiFi模式');
              }
            }
          } catch (e) {
            logger.error('切换连接模式失败', e);
          }
        } else {
          logger.warn('网络连接测试失败', result.error);
          
          this.triggerEvent('reconnect', {
            success: false,
            error: result.error
          });
          
          // 显示连接失败提示
          wx.showToast({
            title: '网络连接失败，请检查网络设置',
            icon: 'none',
            duration: 2000
          });
        }
        
        this.setData({
          reconnecting: false
        });
      });
    },
    
    /**
     * 忽略重连提示
     */
    ignoreReconnect() {
      this.setData({
        showReconnectTips: false
      });
    },
    
    /**
     * 保存当前设置到本地
     * @param {Object} settings - 设备设置
     */
    saveLocalSettings(settings) {
      const deviceId = this.data.deviceId;
      if (!deviceId || !settings) return;
      
      try {
        // 保存设置到本地存储
        wx.setStorageSync(`device_settings_${deviceId}`, JSON.stringify(settings));
        wx.setStorageSync(`device_sync_time_${deviceId}`, Date.now());
        
        this.setData({
          cachedSettings: settings,
          lastSyncTime: Date.now()
        });
        
        this._formatSyncTime();
        
        logger.info(`设备[${deviceId}]的设置已保存到本地`);
        
        // 如果处于离线模式，尝试同步到设备
        if (this.data.isOffline) {
          this._syncLocalSettings();
        }
      } catch (e) {
        logger.error(`保存设备[${deviceId}]设置到本地失败`, e);
      }
    },
    
    /**
     * 更新设备信息
     * @param {Object} deviceInfo - 设备信息
     */
    updateDeviceInfo(deviceInfo) {
      const deviceId = this.data.deviceId;
      if (!deviceId || !deviceInfo) return;
      
      try {
        // 合并设备信息
        const device = {
          ...this.data.device,
          ...deviceInfo
        };
        
        // 保存到本地存储
        wx.setStorageSync(`device_cache_${deviceId}`, JSON.stringify(device));
        
        this.setData({
          device: device
        });
        
        logger.info(`设备[${deviceId}]的信息已更新`);
      } catch (e) {
        logger.error(`更新设备[${deviceId}]信息失败`, e);
      }
    },
    
    /**
     * 是否有本地缓存数据
     * @returns {boolean} 是否有缓存数据
     */
    hasCachedData() {
      return !!this.data.device;
    },
    
    /**
     * 获取最后同步时间
     * @returns {number|null} 最后同步时间戳或null
     */
    getLastSyncTime() {
      return this.data.lastSyncTime;
    }
  }
}); 